#include "grpobjet.h"
#include <string.h>
#include <assert.h>
#include <stdlib.h>
/** Fonction Get **/
int getconsoGrpObjet(const GrpObjet* G, int IndiceObjet)
{
    return getconsoObjet(&G->Groupe[IndiceObjet]);
}

float getcadenceGrpObjet(const GrpObjet* G, int IndiceObjet)
{
    return getcadenceObjet(&G->Groupe[IndiceObjet]);
}

int GetTailleGrpObjet(const GrpObjet * G)
{
  return G->tailleutilise;
}

int getyGrpObjet(const GrpObjet* G, int IndiceObjet)
{
  return getyObjet(&G->Groupe[IndiceObjet]);
}

int getxGrpObjet(const GrpObjet* G, int IndiceObjet)
{
  return getxObjet(&G->Groupe[IndiceObjet]);
}

int getForceGrpObjet(const GrpObjet* G, int IndiceObjet)
{
  return getForceObjet(&G->Groupe[IndiceObjet]);
}

float getPorteeGrpObjet(const GrpObjet* G, int IndiceObjet)
{
  return getPorteeObjet(&G->Groupe[IndiceObjet]);
}


int getidObjetGrpObjet(const GrpObjet* G, int IndiceObjet)
{
  return getidObjetObjet(&G->Groupe[IndiceObjet]);
}

Objet* getObjetGrpObjet(const GrpObjet* G, int IndiceObjet)
{
    return &G->Groupe[IndiceObjet];
}


/** Fonction Set **/
void setconsoGrpObjet(GrpObjet* G,int IndiceObjet,int conso)
{
    setconsoObjet(&G->Groupe[IndiceObjet], conso);
}

void setcadenceGrpObjet(GrpObjet* G, int IndiceObjet , float cadence)
{
    setcadenceObjet(&G->Groupe[IndiceObjet], cadence);
}

void setxyGrpObjet(GrpObjet* G, int IndiceObjet , int x , int y)
{
  setxyObjet(&G->Groupe[IndiceObjet], x, y);
}

void setForceGrpObjet(GrpObjet* G, int IndiceObjet , int Force)
{
  setForceObjet(&G->Groupe[IndiceObjet], Force);
}

void setPorteeGrpObjet(GrpObjet* G, int IndiceObjet , float Portee)
{
  setPorteeObjet(&G->Groupe[IndiceObjet], Portee);
}

void setidObjetGrpObjet(GrpObjet* G, int IndiceObjet , int idObjet)
{
  setidObjetObjet(&G->Groupe[IndiceObjet], idObjet);
}

void copieGrpObjet(GrpObjet * G, int IndiceObjet, Objet * destination)
{
  copieObjet(destination, &G->Groupe[IndiceObjet]);
}

void AjouterGrpObjetaleatoire(GrpObjet * G,int x,int y,int difficulte)
{
    Objet O;
    if (rand()%(difficulte+1)==0)
    {
        InitObjet(&O,"VIE",x,y);
        AjouterGrpObjet(G,&O);
        return;
    }
    if (difficulte>=3&&rand()%6==0)
    {
        InitObjet(&O,"VIEMAX",x,y);
        AjouterGrpObjet(G,&O);
        return;
    }
    if (difficulte>=2&&rand()%6==0)
    {
        InitObjet(&O,"VITESSE",x,y);
        AjouterGrpObjet(G,&O);
        return;
    }
    if (difficulte>=2&&rand()%6==0)
    {
        InitObjet(&O,"CADENCE",x,y);
        AjouterGrpObjet(G,&O);
        return;
    }
    if (difficulte>=2&&rand()%6==0)
    {
        InitObjet(&O,"PORTEE",x,y);
        AjouterGrpObjet(G,&O);
        return;
    }
    if (rand()%3==0)
    {
        InitObjet(&O,"FORCE",x,y);
        AjouterGrpObjet(G,&O);
        return;
    }
    if (rand()%6==0&&difficulte<=2)
    {
        InitObjet(&O,"PISTOLET",x,y);
        AjouterGrpObjet(G,&O);
        return;
    }
    if (rand()%7==0)
    {
        InitObjet(&O,"FUSILPOMPE",x,y);
        AjouterGrpObjet(G,&O);
        return;
    }
    if (rand()%7==0)
    {
        InitObjet(&O,"EPEECRAFT",x,y);
        AjouterGrpObjet(G,&O);
        return;
    }
    if (difficulte>=2&&rand()%10==0)
    {
        InitObjet(&O,"CHAPEAUFEU",x,y);
        AjouterGrpObjet(G,&O);
        return;
    }
    if (difficulte>=3&&rand()%10==0)
    {
        InitObjet(&O,"CHAPEAUFOUDRE",x,y);
        AjouterGrpObjet(G,&O);
        return;
    }
    if (difficulte>=4&&rand()%10==0)
    {
        InitObjet(&O,"BAZOOKA",x,y);
        AjouterGrpObjet(G,&O);
        return;
    }

    InitObjet(&O,"VIE",x,y);
    AjouterGrpObjet(G,&O);
}

/** Fonctions liées au groupe **/

GrpObjet * InitGrpObjet(int taillemax)
{
  GrpObjet * G=NULL;
  G = malloc(sizeof(GrpObjet));
  assert(G!=NULL);
  G->tailleutilise = 0;
  G->taillemax = taillemax;
  G->Groupe = malloc(taillemax * sizeof(Objet));
  return G;
}

int GetnbGrpObjet(GrpObjet * G)
{
    return G->tailleutilise;
}

void AjouterGrpObjet(GrpObjet * G, Objet * O)
{
  if (G->tailleutilise < G->taillemax)
  {
    memcpy(&G->Groupe[G->tailleutilise], O, sizeof(Objet));
    G->tailleutilise++;
  }
}

void SupprGrpObjet(GrpObjet * G, int IndiceObjet)
{
  int i;
  i = IndiceObjet;
  while (i < G->taillemax-1)
  {
    memcpy(&G->Groupe[i], &G->Groupe[i+1], sizeof(Objet));
    i++;
  }
  G->tailleutilise--;
}

void TestamentGrpObjet(GrpObjet * G)
{
  free(G->Groupe);
  G->tailleutilise = 0;
  G->taillemax = 0;
  free(G);
}

